package com.ulwx.tool.path;
import com.ulwx.tool.Assert;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.net.*;
import java.util.*;
import java.util.jar.JarEntry;
import java.util.jar.JarFile;
import java.util.zip.ZipException;


class PathMatchingResourcePatternResolver implements ResourcePatternResolver {

   private static final Log logger = LogFactory.getLog(PathMatchingResourcePatternResolver.class);

   private static Method equinoxResolveMethod;

   static {
       try {
           // Detect Equinox OSGi (e.g. on WebSphere 6.1)
           Class<?> fileLocatorClass = Class.forName("org.eclipse.core.runtime.FileLocator",true,
                   PathMatchingResourcePatternResolver.class.getClassLoader());
           equinoxResolveMethod = fileLocatorClass.getMethod("resolve", URL.class);
           logger.trace("Found Equinox FileLocator for OSGi bundle URL resolution");
       }
       catch (Throwable ex) {
           equinoxResolveMethod = null;
       }
   }


   private final ResourceLoader resourceLoader;

   private PathMatcher pathMatcher = new AntPathMatcher();



   public PathMatchingResourcePatternResolver() {
       this.resourceLoader = new DefaultResourceLoader();
   }

   /**
    * Create a new PathMatchingResourcePatternResolver.
    * <p>ClassLoader access will happen via the thread context class loader.
    * @param resourceLoader the ResourceLoader to load root directories and
    * actual resources with
    */
   public PathMatchingResourcePatternResolver(ResourceLoader resourceLoader) {
       Assert.notNull(resourceLoader, "ResourceLoader must not be null");
       this.resourceLoader = resourceLoader;
   }


   public PathMatchingResourcePatternResolver( ClassLoader classLoader) {
       this.resourceLoader = new DefaultResourceLoader(classLoader);
   }


   /**
    * Return the ResourceLoader that this pattern resolver works with.
    */
   private ResourceLoader getResourceLoader() {
       return this.resourceLoader;
   }

   @Override

   public ClassLoader getClassLoader() {
       return getResourceLoader().getClassLoader();
   }

   /**
    * Set the PathMatcher implementation to use for this
    * resource pattern resolver. Default is AntPathMatcher.
    */
   private void setPathMatcher(PathMatcher pathMatcher) {
       Assert.notNull(pathMatcher, "PathMatcher must not be null");
       this.pathMatcher = pathMatcher;
   }

   /**
    * Return the PathMatcher that this resource pattern resolver uses.
    */
   private PathMatcher getPathMatcher() {
       return this.pathMatcher;
   }


   @Override
   public Resource getResource(String location) {
       return getResourceLoader().getResource(location);
   }

   @Override
   public Resource[] getResources(String locationPattern) throws IOException {
       Assert.notNull(locationPattern, "Location pattern must not be null");
       if (locationPattern.startsWith(CLASSPATH_ALL_URL_PREFIX)) {
           // a class path resource (multiple resources for same name possible)
           if (getPathMatcher().isPattern(locationPattern.substring(CLASSPATH_ALL_URL_PREFIX.length()))) {
               // a class path resource pattern
               return findPathMatchingResources(locationPattern);
           }
           else {
               // all class path resources with the given name
               return findAllClassPathResources(locationPattern.substring(CLASSPATH_ALL_URL_PREFIX.length()));
           }
       }
       else {
           // Generally only look for a pattern after a prefix here,
           // and on Tomcat only after the "*/" separator for its "war:" protocol.
           int prefixEnd = (locationPattern.startsWith("war:") ? locationPattern.indexOf("*/") + 1 :
                   locationPattern.indexOf(':') + 1);
           if (getPathMatcher().isPattern(locationPattern.substring(prefixEnd))) {
               // a file pattern
               return findPathMatchingResources(locationPattern);
           }
           else {
               // a single resource with the given name
               return new Resource[] {getResourceLoader().getResource(locationPattern)};
           }
       }
   }

   /**
    * Find all class location resources with the given location via the ClassLoader.
    * Delegates to {@link #doFindAllClassPathResources(String)}.
    * @param location the absolute path within the classpath
    * @return the result as Resource array
    * @throws IOException in case of I/O errors
    * @see ClassLoader#getResources
    * @see #convertClassLoaderURL
    */
   protected Resource[] findAllClassPathResources(String location) throws IOException {
       String path = location;
       if (path.startsWith("/")) {
           path = path.substring(1);
       }
       Set<Resource> result = doFindAllClassPathResources(path);
       if (logger.isTraceEnabled()) {
           logger.trace("Resolved classpath location [" + location + "] to resources " + result);
       }
       return result.toArray(new Resource[0]);
   }

   /**
    * Find all class location resources with the given path via the ClassLoader.
    * Called by {@link #findAllClassPathResources(String)}.
    * @param path the absolute path within the classpath (never a leading slash)
    * @return a mutable Set of matching Resource instances
    * @since 4.1.1
    */
   protected Set<Resource> doFindAllClassPathResources(String path) throws IOException {
       Set<Resource> result = new LinkedHashSet<>(16);
       ClassLoader cl = getClassLoader();
       Enumeration<URL> resourceUrls = (cl != null ? cl.getResources(path) : ClassLoader.getSystemResources(path));
       while (resourceUrls.hasMoreElements()) {
           URL url = resourceUrls.nextElement();
           result.add(convertClassLoaderURL(url));
       }
       if (!PStringUtils.hasLength(path)) {
           // The above result is likely to be incomplete, i.e. only containing file system references.
           // We need to have pointers to each of the jar files on the classpath as well...
           addAllClassLoaderJarRoots(cl, result);
       }
       return result;
   }

   /**
    * Convert the given URL as returned from the ClassLoader into a {@link Resource}.
    * <p>The default implementation simply creates a {@link UrlResource} instance.
    * @param url a URL as returned from the ClassLoader
    * @return the corresponding Resource object
    * @see ClassLoader#getResources
    */
   protected Resource convertClassLoaderURL(URL url) {
       return new UrlResource(url);
   }

   /**
    * Search all {@link URLClassLoader} URLs for jar file references and add them to the
    * given set of resources in the form of pointers to the root of the jar file content.
    * @param classLoader the ClassLoader to search (including its ancestors)
    * @param result the set of resources to add jar roots to
    * @since 4.1.1
    */
   protected void addAllClassLoaderJarRoots( ClassLoader classLoader, Set<Resource> result) {
       if (classLoader instanceof URLClassLoader) {
           try {
               for (URL url : ((URLClassLoader) classLoader).getURLs()) {
                   try {
                       UrlResource jarResource = (PResourceUtils.URL_PROTOCOL_JAR.equals(url.getProtocol()) ?
                               new UrlResource(url) :
                               new UrlResource(PResourceUtils.JAR_URL_PREFIX + url + PResourceUtils.JAR_URL_SEPARATOR));
                       if (jarResource.exists()) {
                           result.add(jarResource);
                       }
                   }
                   catch (MalformedURLException ex) {
                       if (logger.isDebugEnabled()) {
                           logger.debug("Cannot search for matching files underneath [" + url +
                                   "] because it cannot be converted to a valid 'jar:' URL: " + ex.getMessage());
                       }
                   }
               }
           }
           catch (Exception ex) {
               if (logger.isDebugEnabled()) {
                   logger.debug("Cannot introspect jar files since ClassLoader [" + classLoader +
                           "] does not support 'getURLs()': " + ex);
               }
           }
       }

       if (classLoader == ClassLoader.getSystemClassLoader()) {
           // "java.class.path" manifest evaluation...
           addClassPathManifestEntries(result);
       }

       if (classLoader != null) {
           try {
               // Hierarchy traversal...
               addAllClassLoaderJarRoots(classLoader.getParent(), result);
           }
           catch (Exception ex) {
               if (logger.isDebugEnabled()) {
                   logger.debug("Cannot introspect jar files in parent ClassLoader since [" + classLoader +
                           "] does not support 'getParent()': " + ex);
               }
           }
       }
   }

   /**
    * Determine jar file references from the "java.class.path." manifest property and add them
    * to the given set of resources in the form of pointers to the root of the jar file content.
    * @param result the set of resources to add jar roots to
    * @since 4.3
    */
   protected void addClassPathManifestEntries(Set<Resource> result) {
       try {
           String javaClassPathProperty = System.getProperty("java.class.path");
           for (String path : PStringUtils.delimitedListToStringArray(
                   javaClassPathProperty, System.getProperty("path.separator"))) {
               try {
                   String filePath = new File(path).getAbsolutePath();
                   int prefixIndex = filePath.indexOf(':');
                   if (prefixIndex == 1) {
                       // Possibly "c:" drive prefix on Windows, to be upper-cased for proper duplicate detection
                       filePath = PStringUtils.capitalize(filePath);
                   }
                   UrlResource jarResource = new UrlResource(PResourceUtils.JAR_URL_PREFIX +
                           PResourceUtils.FILE_URL_PREFIX + filePath + PResourceUtils.JAR_URL_SEPARATOR);
                   // Potentially overlapping with URLClassLoader.getURLs() result above!
                   if (!result.contains(jarResource) && !hasDuplicate(filePath, result) && jarResource.exists()) {
                       result.add(jarResource);
                   }
               }
               catch (MalformedURLException ex) {
                   if (logger.isDebugEnabled()) {
                       logger.debug("Cannot search for matching files underneath [" + path +
                               "] because it cannot be converted to a valid 'jar:' URL: " + ex.getMessage());
                   }
               }
           }
       }
       catch (Exception ex) {
           if (logger.isDebugEnabled()) {
               logger.debug("Failed to evaluate 'java.class.path' manifest entries: " + ex);
           }
       }
   }

   /**
    * Check whether the given file path has a duplicate but differently structured entry
    * in the existing result, i.e. with or without a leading slash.
    * @param filePath the file path (with or without a leading slash)
    * @param result the current result
    * @return {@code true} if there is a duplicate (i.e. to ignore the given file path),
    * {@code false} to proceed with adding a corresponding resource to the current result
    */
   private boolean hasDuplicate(String filePath, Set<Resource> result) {
       if (result.isEmpty()) {
           return false;
       }
       String duplicatePath = (filePath.startsWith("/") ? filePath.substring(1) : "/" + filePath);
       try {
           return result.contains(new UrlResource(PResourceUtils.JAR_URL_PREFIX + PResourceUtils.FILE_URL_PREFIX +
                   duplicatePath + PResourceUtils.JAR_URL_SEPARATOR));
       }
       catch (MalformedURLException ex) {
           // Ignore: just for testing against duplicate.
           return false;
       }
   }

   /**
    * Find all resources that match the given location pattern via the
    * Ant-style PathMatcher. Supports resources in jar files and zip files
    * and in the file system.
    * @param locationPattern the location pattern to match
    * @return the result as Resource array
    * @throws IOException in case of I/O errors
    * @see #doFindPathMatchingJarResources
    * @see #doFindPathMatchingFileResources
    */
   protected Resource[] findPathMatchingResources(String locationPattern) throws IOException {
       String rootDirPath = determineRootDir(locationPattern);
       String subPattern = locationPattern.substring(rootDirPath.length());
       Resource[] rootDirResources = getResources(rootDirPath);
       Set<Resource> result = new LinkedHashSet<>(16);
       for (Resource rootDirResource : rootDirResources) {
           rootDirResource = resolveRootDirResource(rootDirResource);
           URL rootDirUrl = rootDirResource.getURL();
           if (equinoxResolveMethod != null && rootDirUrl.getProtocol().startsWith("bundle")) {
               URL resolvedUrl = (URL) PReflectionUtils.invokeMethod(equinoxResolveMethod, null, rootDirUrl);
               if (resolvedUrl != null) {
                   rootDirUrl = resolvedUrl;
               }
               rootDirResource = new UrlResource(rootDirUrl);
           }
           if (rootDirUrl.getProtocol().startsWith(PResourceUtils.URL_PROTOCOL_VFS)) {
               result.addAll(VfsResourceMatchingDelegate.findMatchingResources(rootDirUrl, subPattern, getPathMatcher()));
           }
           else if (PResourceUtils.isJarURL(rootDirUrl) || isJarResource(rootDirResource)) {
               result.addAll(doFindPathMatchingJarResources(rootDirResource, rootDirUrl, subPattern));
           }
           else {
               result.addAll(doFindPathMatchingFileResources(rootDirResource, subPattern));
           }
       }
       if (logger.isTraceEnabled()) {
           logger.trace("Resolved location pattern [" + locationPattern + "] to resources " + result);
       }
       return result.toArray(new Resource[0]);
   }

   /**
    * Determine the root directory for the given location.
    * <p>Used for determining the starting point for file matching,
    * resolving the root directory location to a {@code java.io.File}
    * and passing it into {@code retrieveMatchingFiles}, with the
    * remainder of the location as pattern.
    * <p>Will return "/WEB-INF/" for the pattern "/WEB-INF/*.xml",
    * for example.
    * @param location the location to check
    * @return the part of the location that denotes the root directory
    * @see #retrieveMatchingFiles
    */
   protected String determineRootDir(String location) {
       int prefixEnd = location.indexOf(':') + 1;
       int rootDirEnd = location.length();
       while (rootDirEnd > prefixEnd && getPathMatcher().isPattern(location.substring(prefixEnd, rootDirEnd))) {
           rootDirEnd = location.lastIndexOf('/', rootDirEnd - 2) + 1;
       }
       if (rootDirEnd == 0) {
           rootDirEnd = prefixEnd;
       }
       return location.substring(0, rootDirEnd);
   }

   /**
    * Resolve the specified resource for path matching.
    * <p>By default, Equinox OSGi "bundleresource:" / "bundleentry:" URL will be
    * resolved into a standard jar file URL that be traversed using Spring's
    * standard jar file traversal algorithm. For any preceding custom resolution,
    * override this method and replace the resource handle accordingly.
    * @param original the resource to resolve
    * @return the resolved resource (may be identical to the passed-in resource)
    * @throws IOException in case of resolution failure
    */
   protected Resource resolveRootDirResource(Resource original) throws IOException {
       return original;
   }


   protected boolean isJarResource(Resource resource) throws IOException {
       return false;
   }

   /**
    * Find all resources in jar files that match the given location pattern
    * via the Ant-style PathMatcher.
    * @param rootDirResource the root directory as Resource
    * @param rootDirURL the pre-resolved root directory URL
    * @param subPattern the sub pattern to match (below the root directory)
    * @return a mutable Set of matching Resource instances
    * @throws IOException in case of I/O errors
    * @since 4.3
    * @see JarURLConnection
    */
   protected Set<Resource> doFindPathMatchingJarResources(Resource rootDirResource, URL rootDirURL, String subPattern)
           throws IOException {

       URLConnection con = rootDirURL.openConnection();
       JarFile jarFile;
       String jarFileUrl;
       String rootEntryPath;
       boolean closeJarFile;

       if (con instanceof JarURLConnection) {
           // Should usually be the case for traditional JAR files.
           JarURLConnection jarCon = (JarURLConnection) con;
           PResourceUtils.useCachesIfNecessary(jarCon);
           jarFile = jarCon.getJarFile();
           jarFileUrl = jarCon.getJarFileURL().toExternalForm();
           JarEntry jarEntry = jarCon.getJarEntry();
           rootEntryPath = (jarEntry != null ? jarEntry.getName() : "");
           closeJarFile = !jarCon.getUseCaches();
       }
       else {
           // No JarURLConnection -> need to resort to URL file parsing.
           // We'll assume URLs of the format "jar:path!/entry", with the protocol
           // being arbitrary as long as following the entry format.
           // We'll also handle paths with and without leading "file:" prefix.
           String urlFile = rootDirURL.getFile();
           try {
               int separatorIndex = urlFile.indexOf(PResourceUtils.WAR_URL_SEPARATOR);
               if (separatorIndex == -1) {
                   separatorIndex = urlFile.indexOf(PResourceUtils.JAR_URL_SEPARATOR);
               }
               if (separatorIndex != -1) {
                   jarFileUrl = urlFile.substring(0, separatorIndex);
                   rootEntryPath = urlFile.substring(separatorIndex + 2);  // both separators are 2 chars
                   jarFile = getJarFile(jarFileUrl);
               }
               else {
                   jarFile = new JarFile(urlFile);
                   jarFileUrl = urlFile;
                   rootEntryPath = "";
               }
               closeJarFile = true;
           }
           catch (ZipException ex) {
               if (logger.isDebugEnabled()) {
                   logger.debug("Skipping invalid jar classpath entry [" + urlFile + "]");
               }
               return Collections.emptySet();
           }
       }

       try {
           if (logger.isTraceEnabled()) {
               logger.trace("Looking for matching resources in jar file [" + jarFileUrl + "]");
           }
           if (PStringUtils.hasLength(rootEntryPath) && !rootEntryPath.endsWith("/")) {
               // Root entry path must end with slash to allow for proper matching.
               // The Sun JRE does not return a slash here, but BEA JRockit does.
               rootEntryPath = rootEntryPath + "/";
           }
           Set<Resource> result = new LinkedHashSet<>(8);
           for (Enumeration<JarEntry> entries = jarFile.entries(); entries.hasMoreElements();) {
               JarEntry entry = entries.nextElement();
               String entryPath = entry.getName();
               if (entryPath.startsWith(rootEntryPath)) {
                   String relativePath = entryPath.substring(rootEntryPath.length());
                   if(!subPattern.endsWith("/")) {
                       relativePath = PStringUtils.trimTrailingCharacter(relativePath, '/');
                   }else{
                       subPattern= PStringUtils.trimTrailingCharacter(subPattern, '/');
                       relativePath = PStringUtils.trimTrailingCharacter(relativePath, '/');
                   }
                   if (getPathMatcher().match(subPattern, relativePath)) {
                       result.add(rootDirResource.createRelative(relativePath));
                   }
               }
           }
           return result;
       }
       finally {
           if (closeJarFile) {
               jarFile.close();
           }
       }
   }

   /**
    * Resolve the given jar file URL into a JarFile object.
    */
   protected JarFile getJarFile(String jarFileUrl) throws IOException {
       if (jarFileUrl.startsWith(PResourceUtils.FILE_URL_PREFIX)) {
           try {
               return new JarFile(PResourceUtils.toURI(jarFileUrl).getSchemeSpecificPart());
           }
           catch (URISyntaxException ex) {
               // Fallback for URLs that are not valid URIs (should hardly ever happen).
               return new JarFile(jarFileUrl.substring(PResourceUtils.FILE_URL_PREFIX.length()));
           }
       }
       else {
           return new JarFile(jarFileUrl);
       }
   }

   /**
    * Find all resources in the file system that match the given location pattern
    * via the Ant-style PathMatcher.
    * @param rootDirResource the root directory as Resource
    * @param subPattern the sub pattern to match (below the root directory)
    * @return a mutable Set of matching Resource instances
    * @throws IOException in case of I/O errors
    * @see #retrieveMatchingFiles
    */
   protected Set<Resource> doFindPathMatchingFileResources(Resource rootDirResource, String subPattern)
           throws IOException {

       File rootDir;
       try {
           rootDir = rootDirResource.getFile().getAbsoluteFile();
       }
       catch (FileNotFoundException ex) {
           if (logger.isDebugEnabled()) {
               logger.debug("Cannot search for matching files underneath " + rootDirResource +
                       " in the file system: " + ex.getMessage());
           }
           return Collections.emptySet();
       }
       catch (Exception ex) {
           if (logger.isInfoEnabled()) {
               logger.info("Failed to resolve " + rootDirResource + " in the file system: " + ex);
           }
           return Collections.emptySet();
       }
       subPattern= PStringUtils.trimTrailingCharacter(subPattern,'/');
       return doFindMatchingFileSystemResources(rootDir, subPattern);
   }

   /**
    * Find all resources in the file system that match the given location pattern
    * via the Ant-style PathMatcher.
    * @param rootDir the root directory in the file system
    * @param subPattern the sub pattern to match (below the root directory)
    * @return a mutable Set of matching Resource instances
    * @throws IOException in case of I/O errors
    * @see #retrieveMatchingFiles
    */
   protected Set<Resource> doFindMatchingFileSystemResources(File rootDir, String subPattern) throws IOException {
       if (logger.isTraceEnabled()) {
           logger.trace("Looking for matching resources in directory tree [" + rootDir.getPath() + "]");
       }
       Set<File> matchingFiles = retrieveMatchingFiles(rootDir, subPattern);
       Set<Resource> result = new LinkedHashSet<>(matchingFiles.size());
       for (File file : matchingFiles) {
           result.add(new FileSystemResource(file));
       }
       return result;
   }

   /**
    * Retrieve files that match the given path pattern,
    * checking the given directory and its subdirectories.
    * @param rootDir the directory to start from
    * @param pattern the pattern to match against,
    * relative to the root directory
    * @return a mutable Set of matching Resource instances
    * @throws IOException if directory contents could not be retrieved
    */
   protected Set<File> retrieveMatchingFiles(File rootDir, String pattern) throws IOException {
       if (!rootDir.exists()) {
           // Silently skip non-existing directories.
           if (logger.isDebugEnabled()) {
               logger.debug("Skipping [" + rootDir.getAbsolutePath() + "] because it does not exist");
           }
           return Collections.emptySet();
       }
       if (!rootDir.isDirectory()) {
           // Complain louder if it exists but is no directory.
           if (logger.isInfoEnabled()) {
               logger.info("Skipping [" + rootDir.getAbsolutePath() + "] because it does not denote a directory");
           }
           return Collections.emptySet();
       }
       if (!rootDir.canRead()) {
           if (logger.isInfoEnabled()) {
               logger.info("Skipping search for matching files underneath directory [" + rootDir.getAbsolutePath() +
                       "] because the application is not allowed to read the directory");
           }
           return Collections.emptySet();
       }
       String fullPattern = PStringUtils.replace(rootDir.getAbsolutePath(), File.separator, "/");
       if (!pattern.startsWith("/")) {
           fullPattern += "/";
       }
       fullPattern = fullPattern + PStringUtils.replace(pattern, File.separator, "/");
       Set<File> result = new LinkedHashSet<>(8);
       doRetrieveMatchingFiles(fullPattern, rootDir, result);
       return result;
   }

   /**
    * Recursively retrieve files that match the given pattern,
    * adding them to the given result list.
    * @param fullPattern the pattern to match against,
    * with prepended root directory path
    * @param dir the current directory
    * @param result the Set of matching File instances to add to
    * @throws IOException if directory contents could not be retrieved
    */
   protected void doRetrieveMatchingFiles(String fullPattern, File dir, Set<File> result) throws IOException {
       if (logger.isTraceEnabled()) {
           logger.trace("Searching directory [" + dir.getAbsolutePath() +
                   "] for files matching pattern [" + fullPattern + "]");
       }
       for (File content : listDirectory(dir)) {
           String currPath = PStringUtils.replace(content.getAbsolutePath(), File.separator, "/");
           if (content.isDirectory() && getPathMatcher().matchStart(fullPattern, currPath + "/")) {
               if (!content.canRead()) {
                   if (logger.isDebugEnabled()) {
                       logger.debug("Skipping subdirectory [" + dir.getAbsolutePath() +
                               "] because the application is not allowed to read the directory");
                   }
               }
               else {
                   doRetrieveMatchingFiles(fullPattern, content, result);
               }
           }
           if (getPathMatcher().match(fullPattern, currPath)) {
               result.add(content);
           }
       }
   }

   /**
    * Determine a sorted list of files in the given directory.
    * @param dir the directory to introspect
    * @return the sorted list of files (by default in alphabetical order)
    * @since 5.1
    * @see File#listFiles()
    */
   protected File[] listDirectory(File dir) {
       File[] files = dir.listFiles();
       if (files == null) {
           if (logger.isInfoEnabled()) {
               logger.info("Could not retrieve contents of directory [" + dir.getAbsolutePath() + "]");
           }
           return new File[0];
       }
       Arrays.sort(files, Comparator.comparing(File::getName));
       return files;
   }


   /**
    * Inner delegate class, avoiding a hard JBoss VFS API dependency at runtime.
    */
   private static class VfsResourceMatchingDelegate {

       public static Set<Resource> findMatchingResources(
               URL rootDirURL, String locationPattern, PathMatcher pathMatcher) throws IOException {

           Object root = VfsPatternUtils.findRoot(rootDirURL);
           PatternVirtualFileVisitor visitor =
                   new PatternVirtualFileVisitor(VfsPatternUtils.getPath(root), locationPattern, pathMatcher);
           VfsPatternUtils.visit(root, visitor);
           return visitor.getResources();
       }
   }


   /**
    * VFS visitor for path matching purposes.
    */
   @SuppressWarnings("unused")
   private static class PatternVirtualFileVisitor implements InvocationHandler {

       private final String subPattern;

       private final PathMatcher pathMatcher;

       private final String rootPath;

       private final Set<Resource> resources = new LinkedHashSet<>();

       public PatternVirtualFileVisitor(String rootPath, String subPattern, PathMatcher pathMatcher) {
           this.subPattern = subPattern;
           this.pathMatcher = pathMatcher;
           this.rootPath = (rootPath.isEmpty() || rootPath.endsWith("/") ? rootPath : rootPath + "/");
       }

       @Override

       public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
           String methodName = method.getName();
           if (Object.class == method.getDeclaringClass()) {
               if (methodName.equals("equals")) {
                   // Only consider equal when proxies are identical.
                   return (proxy == args[0]);
               }
               else if (methodName.equals("hashCode")) {
                   return System.identityHashCode(proxy);
               }
           }
           else if ("getAttributes".equals(methodName)) {
               return getAttributes();
           }
           else if ("visit".equals(methodName)) {
               visit(args[0]);
               return null;
           }
           else if ("toString".equals(methodName)) {
               return toString();
           }

           throw new IllegalStateException("Unexpected method invocation: " + method);
       }

       public void visit(Object vfsResource) {
           if (this.pathMatcher.match(this.subPattern,
                   VfsPatternUtils.getPath(vfsResource).substring(this.rootPath.length()))) {
               this.resources.add(new VfsResource(vfsResource));
           }
       }


       public Object getAttributes() {
           return VfsPatternUtils.getVisitorAttributes();
       }

       public Set<Resource> getResources() {
           return this.resources;
       }

       public int size() {
           return this.resources.size();
       }

       @Override
       public String toString() {
           return "sub-pattern: " + this.subPattern + ", resources: " + this.resources;
       }
   }

}
